SGI Developer Toolbox 6.1/SGI Developer Toolbox 6.1 - Disc 1.iso/toolbox/src/tutorials/custEducation/opengl2/examples/adv_texture/reflection.c

C/C++ Source or Header | 1996-11-11 | 4.6 KB | 200 lines

/*
 * Copyright 1993, 1996, Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
 * the contents of this file may not be disclosed to third parties, copied or
 * duplicated in any form, in whole or in part, without the prior written
 * permission of Silicon Graphics, Inc.
 *
 * RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
 * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
 * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
 * rights reserved under the Copyright Laws of the United States.
 */

/* reflection.c
 * This program reads in a texture from a .rgb file, sets up the
 * texture and the texture environment, then applies the texture
 * to a polygon using sphere mapping to automatically generated
 * texture coordinates.
 *
 *    Escape Key    - exit program
 */
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

#include <math.h>
#include <stdio.h>

#include "rgbImageFile.h"    /* should be in ../../include */

/*  Function Prototypes  */

GLvoid  initgfx( GLvoid );
GLvoid  animate( GLvoid );
GLvoid  visibility( GLint );
GLvoid  drawScene( GLvoid );
GLvoid  reshape( GLsizei, GLsizei );
GLvoid  keyboard( GLubyte, GLint, GLint );

GLvoid  initTexture( unsigned int *, GLsizei, GLsizei );

void  printHelp( char *progname );

/* Global Definitions */

#define KEY_ESC    27    /* ascii value for the escape key */

/* Global Variables */

static GLfloat spin = 1.0;

void
main( int argc, char *argv[] )
{
    char        *imageFileName = "flowers.rgb";
    unsigned int     *image;
    GLsizei        width, height, imageWidth, imageHeight;

    glutInit( &argc, argv );

    if (argc < 2) {
        fprintf (stderr, "usage: %s <imageFileName>\n", argv[0] );
    } else
        imageFileName = argv[1];

    fprintf( stdout, "using image %s\n", imageFileName );

    image = rgbReadImageFile(imageFileName, &imageWidth,
             &imageHeight);

    /* create a window that is 1/4 the size of the screen */

    width = glutGet( GLUT_SCREEN_WIDTH );
    height = glutGet( GLUT_SCREEN_HEIGHT );
    glutInitWindowPosition( (width / 2) + 4, height / 4 );
    glutInitWindowSize( (width / 2) - 4, height / 2 );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
    glutCreateWindow( argv[0] );

    initTexture( image, imageWidth, imageHeight );
    initgfx();

    glutKeyboardFunc( keyboard );
    glutIdleFunc( animate );
    glutVisibilityFunc( visibility );
    glutReshapeFunc( reshape );
    glutDisplayFunc( drawScene );

    printHelp( argv[0] );

    glutMainLoop();
}

GLvoid
printHelp( char *progname )
{
    fprintf(stdout, "\n%s - demonstrates reflection mapping\n"
        "Escape key     - exit the program\n\n",
        progname );
}

GLvoid
initgfx( void )
{
    glEnable( GL_DEPTH_TEST );

    glClearColor( 0, 0, 0, 1 );
}

GLvoid initTexture( unsigned int *image,
    GLsizei imageWidth, GLsizei imageHeight )
{
    /* scale texture image, make mipmaps and load texture
     *    gluBuild2DMipmaps( target, components, width, height,
     *        format,  type, imageArray )
     */
    gluBuild2DMipmaps( GL_TEXTURE_2D, 4, imageWidth, imageHeight,
             GL_RGBA, GL_UNSIGNED_BYTE, image );

    /* Set texture coordinate generation function for both
     * the s and t planes to sphere map mode.  Texture
     * will appear to reflect the environment.
     */
    glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
    glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );

    /* Enable automatic texture coordinate generation for
     * both the s and t planes
     */
    glEnable( GL_TEXTURE_GEN_S );
    glEnable( GL_TEXTURE_GEN_T );

    glEnable( GL_TEXTURE_2D );
}

GLvoid
keyboard( GLubyte key, GLint x, GLint y )
{
    switch (key) {
    case KEY_ESC:    /* Exit when the Escape key is pressed */
        exit(0);
    }
}

GLvoid
animate( GLvoid )
{
    spin = fmodf( spin + 3.0, 360.0 );

    /* Tell GLUT to redraw the scene */
    glutPostRedisplay();
}

GLvoid
visibility( int state )
{
    if (state == GLUT_VISIBLE) {
        glutIdleFunc( animate );
    } else {
        glutIdleFunc( NULL );
    }
}

GLvoid
reshape( GLsizei width, GLsizei height )
{
    GLdouble     aspect;

    glViewport( 0, 0, width, height );

    aspect = (GLdouble) width / (GLdouble) height;

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 45.0, aspect, 3.0, 15.0 );
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    glTranslatef( 0.0, 0.0, -12.0 );
}

GLvoid
drawScene(void)
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glColor4f( 1.0, 1.0, 1.0, 1.0 );
    glPushMatrix ();
        glRotatef(spin + 120.0, 0.0, 1.0, 0.0);
        glTranslatef(3.0, 0.0, 0.0);
        glutSolidSphere( 1.0, 32, 32 );
    glPopMatrix ();

    glutSwapBuffers();
}